home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 November / Chip Kasım 2001.iso / prog / cdcode / vmware / setup.exe / data1.cab / WGS_PerlInit / init.pl
Encoding:
Perl Script  |  2001-09-19  |  23.5 KB  |  916 lines
  1. #!/usr/bin/perl -w
  2.  
  3. #############################################################
  4. # Copyright (C) 1998-2000 VMware, Inc.
  5. # All Rights Reserved
  6. # $Id: init.pl,v 1.46 2001/07/30 19:17:52 mgu Exp $
  7. #############################################################
  8.  
  9. #
  10. # VMServerd configuration script.  This script is used to setup the
  11. # VMserverd server.
  12. #
  13. # This script should be installed in a location that can be found
  14. # by vmserverd.  The location by default is /home/vmware/etc.
  15. #
  16.  
  17.  
  18. #############################################################
  19. # Set up include paths 
  20. #############################################################
  21. BEGIN {
  22.   $ENV{vmware_VMSERVERD} = 1;
  23.   $ENV{vmware_PROFILE} = 0;
  24.  
  25.   if ( $^O eq "MSWin32" ) {
  26.     if (-d '%winlibdir%') {
  27.        $PREFIX_PATH = '%winlibdir%';
  28.     } else {
  29.        $PREFIX_PATH = 'm:/bora-winroot/vmserverdPerl';
  30.     }
  31.     @INC = ("$PREFIX_PATH/5.00503/lib",
  32.         "$PREFIX_PATH/5.00503/lib/MSWin32-x86",
  33.         "$PREFIX_PATH/site/5.00503/lib",
  34.         "$PREFIX_PATH/site/5.00503/lib/MSWin32-x86",
  35.         "$PREFIX_PATH/vmware/perlroot",
  36.         '.'
  37.         );
  38.   } else {
  39.     if( -d '%libdir%' ) {
  40.     $PREFIX_PATH = '%libdir%';
  41.     } else {
  42.     $PREFIX_PATH = '/usr/lib/vmware';
  43.     }
  44.     @INC = ("$PREFIX_PATH/perl5",
  45.         "$PREFIX_PATH/perl5/5.00503",
  46.         "$PREFIX_PATH/perl5/5.00503/i386-linux",
  47.         "$PREFIX_PATH/perl5/site-perl/i386-linux",
  48.         "$PREFIX_PATH/perl5/site_perl/5.005",
  49.         "$PREFIX_PATH/perl5/site_perl/5.005/i386-linux",
  50.         '.'
  51.         );
  52.   }
  53. }
  54.  
  55. #############################################################
  56. # Common modules shared between GSX and ESX.
  57. #############################################################
  58. use strict;
  59. use VMware::VMServerd qw(&Log);
  60. use VMware::DOMAccess;
  61. use VMware::VMServerd::EventLog;
  62. use VMware::VMServerd::Who;
  63. use VMware::VMServerd::Info;
  64. use VMware::VMServerd::Mac;
  65. use VMware::VMServerd::Query;
  66. use VMware::VMServerd::Stats;
  67. use VMware::VMServerd::HTTP;
  68. use VMware::VMServerd::VMList;
  69.  
  70. BEGIN {
  71.     no strict;
  72.     $IS_GSX = '@@IS_WGS_SERVER@@';
  73.     $IS_ESX = '@@IS_SCALABLE_SERVER@@';
  74.  
  75.  
  76.     if( $IS_ESX ) {
  77.     # Put modules that belong to ESX here
  78.     require VMware::VMServerd::ESXHostInfo;
  79.     require VMware::VMServerd::ESXHostEdit;
  80.     require VMware::VMServerd::FileSystem;
  81.     require VMware::VMServerd::ESXResourceInfo;
  82.     require VMware::VMServerd::ESXResourceEdit;
  83.     require VMware::VMServerd::ESXVMConfigInfo;
  84.     require VMware::VMServerd::ESXVMConfigEdit;
  85.     require VMware::VMServerd::ESXVMDeleteInfo;
  86.     require VMware::VMServerd::ESXVMDeleteEdit;
  87.     }
  88.  
  89.     if( $IS_GSX ) {
  90.     # Put modules that belong to GSX here
  91.         require VMware::VMServerd::Disk;
  92.     require VMware::VMServerd::VMDeleteInfo;
  93.     require VMware::VMServerd::VMDeleteEdit;
  94.     require VMware::VMServerd::GSXHostInfo;
  95.     }
  96. }
  97.  
  98. #############################################################
  99. # Turn on verbose error/warning reporting by uncommenting
  100. # the following line:
  101. #############################################################
  102. #&VMware::VMServerd::setVerbose(1);
  103.  
  104. #############################################################
  105. # Define operations and the Perl functions to be executed
  106. # when a request for such an operation is received.
  107. # Permissions information is also indicated here.
  108. #############################################################
  109. VMware::VMServerd::addOperation( OPNAME    => 'inc',
  110.                  PERLFUNC  => 'main::increment' );
  111.  
  112. VMware::VMServerd::addOperation( OPNAME    => 'dec',
  113.                  PERLFUNC  => 'main::decrement' );
  114.  
  115. VMware::VMServerd::addOperation( OPNAME    => 'div',
  116.                  PERLFUNC  => 'main::divide' );
  117.  
  118. VMware::VMServerd::addOperation( OPNAME    => 'Directory_List',
  119.                  PERLFUNC  => 'VMware::VMServerd::Handlers::Directory_List_Handler',
  120.                  POLICY => 'authuser' );
  121.  
  122. VMware::VMServerd::addOperation( OPNAME    => 'Directory_Make',
  123.                  PERLFUNC  => 'VMware::VMServerd::Handlers::Directory_Make_Handler',
  124.                  POLICY => 'authuser' );
  125.  
  126. VMware::VMServerd::addOperation( OPNAME    => 'Directory_Remove',
  127.                  PERLFUNC  => 'VMware::VMServerd::Handlers::Directory_Remove_Handler',
  128.                  POLICY => 'authuser' );
  129.  
  130. VMware::VMServerd::addOperation( OPNAME    => 'Directory_GetSpaceUsage',
  131.                  PERLFUNC  => 'VMware::VMServerd::Handlers::Directory_GetSpaceUsage_Handler',
  132.                  POLICY => 'authuser' );
  133.  
  134. VMware::VMServerd::addOperation( OPNAME => 'File_Create',
  135.                  PERLFUNC => 'VMware::VMServerd::Handlers::File_Create_Handler',
  136.                  POLICY => 'authuser' );
  137.  
  138. VMware::VMServerd::addOperation( OPNAME => 'File_Read',
  139.                  PERLFUNC => 'VMware::VMServerd::Handlers::File_Read_Handler',
  140.                  POLICY => 'authuser' );
  141.  
  142. VMware::VMServerd::addOperation( OPNAME => 'File_Exists',
  143.                  PERLFUNC => 'VMware::VMServerd::Handlers::File_Exists_Handler',
  144.                  POLICY => 'authuser' );
  145.  
  146. VMware::VMServerd::addOperation( OPNAME => 'File_Copy',
  147.                  PERLFUNC => 'VMware::VMServerd::Handlers::File_Copy_Handler',
  148.                  POLICY => 'authuser' );
  149.  
  150. VMware::VMServerd::addOperation( OPNAME => 'File_Delete',
  151.                  PERLFUNC => 'VMware::VMServerd::Handlers::File_Delete_Handler',
  152.                  POLICY => 'authuser' );
  153.  
  154. VMware::VMServerd::addOperation( OPNAME => 'Host_GetVirtualNet',
  155.                  PERLFUNC => 'VMware::VMServerd::Handlers::Host_GetVirtualNet_Handler',
  156.                  POLICY => 'authuser' );
  157.  
  158. VMware::VMServerd::addOperation( OPNAME => 'Host_GetBridgedNet',
  159.                  PERLFUNC => 'VMware::VMServerd::Handlers::Host_GetBridgedNet_Handler',
  160.                  POLICY => 'authuser' );
  161.  
  162. VMware::VMServerd::addOperation( OPNAME => 'Host_GetHostOnlyNet',
  163.                  PERLFUNC => 'VMware::VMServerd::Handlers::Host_GetHostOnlyNet_Handler',
  164.                  POLICY => 'authuser' );
  165.  
  166. Log("\nFiles included by init.pl:\n");
  167. my $f;
  168. foreach $f (keys(%INC)) {
  169.     my $abspath = $INC{$f};
  170.     Log("   module $f -> $abspath\n");
  171. }
  172. Log("\n\n" .
  173.     "Operations defined in function table:\n" .
  174.     &VMware::VMServerd::dumpOperation() .
  175.     "\n"
  176.     );
  177.  
  178. #############################################################
  179. # Some sample Perl request handling functions.  These are 
  180. # sample functions and should really go in a separate file
  181. #############################################################
  182. sub increment($$) {
  183.     my $in = shift;
  184.     my $out = shift;
  185.  
  186.     my $s;
  187.     $s = $in->getValue(".number");
  188.     $s++;
  189.  
  190.     $out->setValue(".number", $s);
  191.     
  192.     return(1);
  193. }    
  194.  
  195. sub decrement($$) {
  196.     my $in = shift;
  197.     my $out = shift;
  198.  
  199.     my $s;
  200.     $s = $in->getValue(".number");
  201.     $s--;
  202.  
  203.     $out->setValue(".number", $s);
  204.     
  205.     return(1);
  206. }    
  207.  
  208. sub divide($$) {
  209.     my $in = shift;
  210.     my $out = shift;
  211.     
  212.     my($s, $t);
  213.     $s = $in->getValue(".number1");
  214.     $t = $in->getValue(".number2");
  215.  
  216.     if( $t == 0 ) {
  217.     die "Divide by zero";
  218.     }
  219.     
  220.     $out->setValue(".number", sprintf("%d", $s/$t));
  221.  
  222.     return(1);
  223. }    
  224.  
  225. #############################################################
  226. # Some Perl request handling functions that are common to both
  227. # SS and WGS.  These should be moved elsewhere in the future.
  228. #############################################################
  229. package VMware::VMServerd::Handlers;
  230.  
  231. my %gHelpers = (
  232.     ls => "ls",
  233.     mkdir => "mkdir",
  234.     ifconfig => "ifconfig",
  235.     df => "df"
  236. );
  237.  
  238. my $DEFAULT_DIR_MODE = 0755;
  239. my $DEFAULT_FILE_MODE = 0644;
  240.  
  241. sub isAbsolutePath($) {
  242.     my ($file) = @_;
  243.  
  244.     if (($^O =~ /MSWin32/i) &&
  245.          (($file =~ /^[a-zA-Z]:/) || ($file =~ /^\\/))) {
  246.         return 1;
  247.     }
  248.     if (($^O =~ /linux/i) &&
  249.           (substr($file, 0, 1) eq '/')) {
  250.         return 1;
  251.     }
  252.  
  253.     return 0;
  254. }
  255.  
  256. #
  257. # Gets a list of files from a directory.  
  258. #
  259. # Input format:
  260. #   directory := the absolute path name of the directory 
  261. # 
  262. # Output includes information about each file.  
  263. # Output format:
  264. #
  265. #   file.name := the path name of the file relative to the directory
  266. #   file.type := regular | directory | symlink | FIFO | socket |
  267. #                block | char | tty | unknown
  268. #   file.mode := an integer corresponding to the mode of the file
  269. #   file.uid := integer corresponding to owner of file
  270. #   file.gid := integer corresponding to group of file
  271. #   file.size := size of file in bytes
  272. #   file.atime := last access time since the epoch in milliseconds
  273. #   file.mtime := last modified time since the epoch in milliseconds
  274. #
  275. # Note that symlinks are simply recognized as the files to which
  276. # they point.  If the symlink is broken, it is ignored.
  277. #
  278. sub Directory_List_Handler($$) {
  279.     my $in = shift;
  280.     my $out = shift; 
  281.     my $dir = $in->getValue(".directory");
  282.  
  283.     &VMware::VMServerd::errorReset();
  284.     # Validation on the input parameters
  285.     if( !defined($dir) || $dir eq "" ) {
  286.     &VMware::VMServerd::errorPost("No directory specified");
  287.     return 0;
  288.     }
  289.  
  290.     if (! isAbsolutePath($dir)) {
  291.     &VMware::VMServerd::errorPost("Not an absolute path $dir");
  292.     return 0;
  293.     }
  294.  
  295.     if( ! -d $dir ) {
  296.     &VMware::VMServerd::errorPost("$dir is not a directory");
  297.     return 0;
  298.     }
  299.  
  300.     # Get the list of files
  301.     local *DIR;
  302.     if( !opendir(DIR, $dir) ) {
  303.     &VMware::VMServerd::errorPost("Cannot open the directory.  Reason: $!");
  304.     return 0;
  305.     }
  306.  
  307.     my @files = readdir(DIR);
  308.     closedir DIR;
  309.  
  310.     my $i;
  311.     for( $i = 0; $i <= $#files; $i++ ) {
  312.         my $abspath = &VMware::ExtHelpers::absolute_path($files[$i], $dir);
  313.  
  314.     my ($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size,
  315.         $atime, $mtime, $ctime, $blksize, $blocks);
  316.  
  317.     # Skip if we can't get file info.
  318.     if( !(($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size,
  319.            $atime, $mtime, $ctime, $blksize, $blocks) = stat($abspath)) ) {
  320.         next;
  321.     }
  322.     
  323.     my $filetype;
  324.     if( -f $abspath ) {
  325.         $filetype = "regular";
  326.     } elsif( -d $abspath ) {
  327.         $filetype = "directory";
  328.     } elsif( -p $abspath ) {
  329.         $filetype = "FIFO";
  330.     } elsif( -S $abspath ) {
  331.         $filetype = "socket";
  332.     } elsif( -b $abspath ) {
  333.         $filetype = "block";
  334.     } elsif( -c $abspath ) {
  335.         $filetype = "char";
  336.     } elsif( -t $abspath ) {
  337.         $filetype = "tty";
  338.     } else {
  339.         $filetype = "";
  340.     }
  341.  
  342.     $out->setValue(".file[$i].name", $files[$i]);
  343.     $out->setValue(".file[$i].type", $filetype);
  344.     $out->setValue(".file[$i].mode", $mode);
  345.     $out->setValue(".file[$i].uid", $uid);
  346.     $out->setValue(".file[$i].gid", $gid);
  347.     $out->setValue(".file[$i].size", $size);
  348.     $out->setValue(".file[$i].atime", $atime);
  349.     $out->setValue(".file[$i].mtime", $mtime);
  350.     }
  351.  
  352.     if (&VMware::VMServerd::haveError()) {
  353.       &VMware::VMServerd::errorPost("");
  354.     }
  355.    
  356.     return(1);
  357. }
  358.  
  359.  
  360. #
  361. # Makes a new directory
  362. #
  363. # Input format:
  364. #   directory := the absolute path name of the directory 
  365. #   mode := the file mode to use.  Uses $DEFAULT_DIR_MODE as default.
  366. # 
  367. # Output includes information about each file.  
  368. # Output format:
  369. #
  370. #   No output on success.
  371. #
  372. sub Directory_Make_Handler($$) {
  373.     my $in = shift;
  374.     my $out = shift; 
  375.     my $dir = $in->getValue(".directory");
  376.     my $mode;
  377.  
  378.     &VMware::VMServerd::errorReset();
  379.  
  380.     if ($in->hasElement(".mode") ) {
  381.     $mode = $in->getValue(".mode");
  382.     if( $mode =~ /^[0-7]+$/ ) {
  383.         $mode = oct($mode);
  384.     } elsif( $mode ne "" ) {
  385.         &VMware::VMServerd::errorPost("Invalid mode specified");
  386.         return 0;
  387.     }
  388.     }
  389.  
  390.     # Validation on the input parameters
  391.     if( !defined($dir) || $dir eq "" ) {
  392.     &VMware::VMServerd::errorPost("No directory specified");
  393.     return 0;
  394.     }
  395.  
  396.     if (! isAbsolutePath($dir)) {
  397.     &VMware::VMServerd::errorPost("Not an absolute path $dir");
  398.     return 0;
  399.     }
  400.  
  401.     if( !defined($mode) || ($mode eq "") ) {
  402.     $mode = $DEFAULT_DIR_MODE;
  403.     }
  404.  
  405.     $dir = &VMware::ExtHelpers::dir_remove_trailing_slashes($dir);
  406.  
  407.     $dir =~ s/^([a-zA-Z]:)//;
  408.     my $driveLetters = defined($1) ? $1 : '';
  409.     my @dirs = ($^O eq "MSWin32") ? split(/\\/, $dir) : split(/\//, $dir);
  410.     my $cdir = $driveLetters;
  411.     my $d;
  412.     foreach $d (@dirs) {
  413.     if( $d eq "" ) {
  414.         next;
  415.     }
  416.     $cdir .= (($^O eq "MSWin32") ? '\\' : '/') . $d;
  417.     if( -d $cdir && $cdir ne $dir ) {
  418.         next;
  419.     } else {
  420.         if( !mkdir($cdir, $mode) ) {
  421.             &VMware::VMServerd::errorPost("mkdir failed. Reason: $! ");
  422.         return 0;
  423.           }
  424.     }
  425.     }
  426.  
  427.     return(1);
  428. }
  429.  
  430.  
  431. #
  432. # Remove a directory
  433. #
  434. # Input format:
  435. #   directory := the absolute path name of the directory 
  436. # 
  437. # Output includes information about each file.  
  438. # Output format:
  439. #
  440. #   No output on success.
  441. #
  442. sub Directory_Remove_Handler($$) {
  443.     my $in = shift;
  444.     my $out = shift; 
  445.     my $dir = $in->getValue(".directory");
  446.  
  447.     &VMware::VMServerd::errorReset();
  448.     # Validation on the input parameters
  449.     if( !defined($dir) || $dir eq "" ) {
  450.     &VMware::VMServerd::errorPost("No directory specified");
  451.     return 0;
  452.     }
  453.  
  454.     if (! isAbsolutePath($dir)) {
  455.     &VMware::VMServerd::errorPost("Not an absolute path $dir");
  456.     return 0;
  457.     }
  458.  
  459.     if( !rmdir($dir) ) {
  460.     &VMware::VMServerd::errorPost("rmdir failed. Reason: $! ");
  461.     return 0;
  462.     }
  463.  
  464.     return(1);
  465. }
  466.  
  467.  
  468. #
  469. # Gets the space information about a directory including the
  470. # amount of space used, free, and total.
  471. #
  472. # Input format:
  473. #   directory := the absolute path name of the directory to 
  474. #                check for free space
  475. # 
  476. # Output includes information about each file.  
  477. # Output format:
  478. #
  479. #   used := number of kbytes that are used
  480. #   free := number of kbytes that are free
  481. #   total := total number of kbytes
  482. #
  483. sub Directory_GetSpaceUsage_Handler($$) {
  484.     my $in = shift;
  485.     my $out = shift; 
  486.     my $dir = $in->getValue(".directory");
  487.  
  488.     &VMware::VMServerd::errorReset();
  489.     # Validation on the input parameters
  490.     if( !defined($dir) || $dir eq "" ) {
  491.     &VMware::VMServerd::errorPost("No directory specified");
  492.     return 0;
  493.     }
  494.  
  495.     if (! isAbsolutePath($dir)) {
  496.     &VMware::VMServerd::errorPost("Not an absolute path $dir");
  497.     return 0;
  498.     }
  499.  
  500.     if( ! -d $dir ) {
  501.     &VMware::VMServerd::errorPost("$dir is not a directory");
  502.     return 0;
  503.     }
  504.  
  505.     local *FD;
  506.     # Use -k to get kbytes
  507.     if( !open(FD, shell_string($gHelpers{df}) . " -k " . shell_string($dir) . " |") ) {
  508.     &VMware::VMServerd::errorPost("Could not execute " . $gHelpers{df});
  509.     return 0;
  510.     }
  511.  
  512.     my $total;
  513.     my $used;
  514.     my $free;
  515.  
  516.     while(<FD>) {
  517.     if( /\/dev\/\S+\s+(\d+)\s+(\d+)\s+(\d+)/ ) {
  518.         $total = $1;
  519.         $used = $2;
  520.         $free = $3;
  521.     }
  522.     }
  523.     close(FD);
  524.  
  525.     if( !defined($total) || !defined($used) || !defined($free) ) {
  526.     &VMware::VMServerd::errorPost("Could not read directory space usage information");
  527.     return 0;
  528.     }
  529.  
  530.     $out->setValue(".total", $total);
  531.     $out->setAttribute(".total", "units", "kbyte");
  532.     $out->setValue(".used", $used);
  533.     $out->setAttribute(".used", "units", "kbyte");
  534.     $out->setValue(".free", $free);
  535.     $out->setAttribute(".free", "units", "kbyte");
  536.  
  537.     return(1);
  538. }
  539.  
  540. #
  541. # Create a file with the given contents
  542. #
  543. # Input format:
  544. #   file := the absolute path name of the file to be created
  545. #   data := the data to put into the new file
  546. #   mode := the mode of the file (optional)
  547. #   o_create := flag to ignore the check for existence of the file.
  548. #               passing 1 to this parameter will cause 
  549. # 
  550. # Output includes information about each file.  
  551. # Output format:
  552. #
  553. #   No output on success.
  554. #
  555. sub File_Create_Handler($$) {
  556.     my $in = shift;
  557.     my $out = shift; 
  558.     my $file = $in->getValue(".file");
  559.     my $data = $in->getValue(".data");
  560.     my $o_create = $in->getValue(".o_create");
  561.     my $mode;
  562.     my $modeStr;
  563.  
  564.     &VMware::VMServerd::errorReset();
  565.  
  566.     if ($in->hasElement(".mode")) {
  567.     $mode = $in->getValue(".mode");
  568.     $modeStr = $mode;
  569.     if( $mode =~ /^[0-7]+$/ ) {
  570.         $mode = oct($mode);
  571.     } elsif( $mode ne "" ) {
  572.         &VMware::VMServerd::errorPost("Invalid mode specified");
  573.         return 0;
  574.     }
  575.     }
  576.  
  577.     # Validation on the input parameters
  578.     if( !defined($file) || $file eq "" ) {
  579.     &VMware::VMServerd::errorPost("No file specified");
  580.     return 0;
  581.     }
  582.  
  583.     if (! isAbsolutePath($file)) {
  584.     &VMware::VMServerd::errorPost("Not an absolute path $file");
  585.     return 0;
  586.     }
  587.  
  588.     if( !defined($mode) || ($mode eq "") ) {
  589.     $mode = $DEFAULT_FILE_MODE;
  590.     }
  591.  
  592.     if( $o_create ne "1" && -e $file ) {
  593.     &VMware::VMServerd::errorPost("File exists");
  594.     return 0;
  595.     }
  596.  
  597.     local *FD;
  598.     if( !open(FD, "> $file") ) {
  599.     &VMware::VMServerd::errorPost("File open failed. Reason: $!");
  600.     return 0;
  601.     }
  602.  
  603.     print FD $data;
  604.     close(FD);
  605.  
  606.     if( !chmod($mode, $file) ) {
  607.     &VMware::VMServerd::errorPost("File created but could not change mode to " . $modeStr);
  608.     return 0;
  609.     }
  610.  
  611.     return(1);
  612. }
  613.  
  614.  
  615. #
  616. # Get the contents of a file.
  617. #
  618. # Input format:
  619. #   file := the absolute path name of the file to be read.
  620. # 
  621. # Output includes information about each file.  
  622. # Output format:
  623. #
  624. #   data := the data in the file
  625. #
  626. sub File_Read_Handler($$) {
  627.     my $in = shift;
  628.     my $out = shift; 
  629.     my $file = $in->getValue(".file");
  630.     my $data = "";
  631.  
  632.     &VMware::VMServerd::errorReset();
  633.     # Validation on the input parameters
  634.     if( !defined($file) || $file eq "" ) {
  635.     &VMware::VMServerd::errorPost("No file specified");
  636.     return 0;
  637.     }
  638.  
  639.     if (! isAbsolutePath($file)) {
  640.     &VMware::VMServerd::errorPost("Not an absolute path $file");
  641.     return 0;
  642.     }
  643.  
  644.     local *FD;
  645.     if( !open(FD, "< $file") ) {
  646.     &VMware::VMServerd::errorPost("Open failed. Reason: $!");
  647.     return 0;
  648.     }
  649.  
  650.     while(<FD>) {
  651.     $data .= $_;
  652.     }
  653.     close(FD);
  654.  
  655.     $out->setValue(".data", $data);
  656.  
  657.     return(1);
  658. }
  659.  
  660.  
  661. #
  662. # Checks if a file/directory exists.  Gets the permissions on the file.
  663. #
  664. # Input format:
  665. #   file := the absolute path name of the file to be read.
  666. # 
  667. # Output includes information about each file.  
  668. # Output format:
  669. #   exists := 0 | 1
  670. #   directory := 0 | 1
  671. #   read := 0 | 1
  672. #   write := 0 | 1
  673. #   execute := 0 | 1
  674. #
  675. sub File_Exists_Handler($$) {
  676.     my $in = shift;
  677.     my $out = shift; 
  678.     my $file = $in->getValue(".file");
  679.  
  680.     &VMware::VMServerd::errorReset();
  681.     $out->setValue(".exists", 0);
  682.     $out->setValue(".directory", 0);
  683.     $out->setValue(".read", 0);
  684.     $out->setValue(".write", 0);
  685.     $out->setValue(".execute", 0);
  686.  
  687.     # Validation on the input parameters
  688.     if( !defined($file) || $file eq "" ) {
  689.       &VMware::VMServerd::errorPost("No file specified");
  690.       return 0;
  691.     }
  692.  
  693.     if (! isAbsolutePath($file)) {
  694.     &VMware::VMServerd::errorPost("Not an absolute path $file");
  695.     return 0;
  696.     }
  697.  
  698.     my $exists = (-e $file ? 1 : 0);
  699.     my $directory = (-d $file ? 1 : 0);
  700.     my $read = (-r $file ? 1 : 0);
  701.     my $write = (-w $file ? 1 : 0);
  702.     my $execute = (-x $file ? 1 : 0);
  703.  
  704.     $out->setValue(".exists", $exists);
  705.     $out->setValue(".directory", $directory);
  706.     $out->setValue(".read", $read);
  707.     $out->setValue(".write", $write);
  708.     $out->setValue(".execute", $execute);
  709.  
  710.     return(1);
  711. }
  712.  
  713.  
  714. #
  715. # Copy a file.
  716. #
  717. # Input format:
  718. #   src := the absolute path name of the file to be read.
  719. #   dest := the absoluate path name of the file to be written.
  720. # 
  721. # Output includes information about each file.  
  722. # Output format:
  723. #
  724. #   No output on success.
  725. #
  726. sub File_Copy_Handler($$) {
  727.     my $in = shift;
  728.     my $out = shift; 
  729.     my $src = $in->getValue(".src");
  730.     my $dest = $in->getValue(".dest");
  731.     my $data = "";
  732.  
  733.     &VMware::VMServerd::errorReset();
  734.     # Validation on the input parameters
  735.     if( !defined($src) || $src eq "" ) {
  736.     &VMware::VMServerd::errorPost("No input file specified");
  737.     return 0;
  738.     }
  739.  
  740.     # Validation on the input parameters
  741.     if( !defined($dest) || $dest eq "" ) {
  742.         &VMware::VMServerd::errorPost("No output file specified");
  743.     return 0;
  744.     }
  745.  
  746.     if (! isAbsolutePath($src)) {
  747.     &VMware::VMServerd::errorPost("Not an absolute path: $src");
  748.     return 0;
  749.     }
  750.  
  751.     if (! isAbsolutePath($dest)) {
  752.     &VMware::VMServerd::errorPost("Not an absolute path: $dest");
  753.     return 0;
  754.     }
  755.  
  756.     local(*RFD, *WFD);
  757.     if( !open(RFD, "< $src") ) {
  758.     &VMware::VMServerd::errorPost("Open for $src failed. Reason: $!");
  759.     return 0;
  760.     }
  761.  
  762.     if( !open(WFD, "> $dest") ) {
  763.     &VMware::VMServerd::errorPost("Open for $dest failed. Reason: $!");
  764.     close(RFD);
  765.     return 0;
  766.     }
  767.  
  768.     # Some crazy OSs distinguish between text and binary files.
  769.     binmode(RFD);
  770.     binmode(WFD);
  771.     
  772.     while(<RFD>) {
  773.     print WFD;
  774.     }
  775.  
  776.     close(RFD);
  777.     close(WFD);
  778.  
  779.     return(1);
  780. }
  781.  
  782.  
  783. #
  784. # Deletes a file.
  785. #
  786. # Input format:
  787. #   file := the absolute path name of the file to be deleted
  788. # 
  789. # Output includes information about each file.  
  790. # Output format:
  791. #
  792. #   No output on success.
  793. #
  794. sub File_Delete_Handler($$) {
  795.     my $in = shift;
  796.     my $out = shift; 
  797.     my $file = $in->getValue(".file");
  798.     my $data = "";
  799.  
  800.     &VMware::VMServerd::errorReset();
  801.  
  802.     # Validation on the input parameters
  803.     if( !defined($file) || $file eq "" ) {
  804.     &VMware::VMServerd::errorPost("No file specified");
  805.     return 0;
  806.     }
  807.  
  808.     if (! isAbsolutePath($file)) {
  809.     &VMware::VMServerd::errorPost("Not an absolute path: $file");
  810.     return 0;
  811.     }
  812.  
  813.     # Make sure this is a regular file.  Otherwise, we could get
  814.     # some bad side effects.
  815.     if( ! -f $file ) {
  816.         &VMware::VMServerd::errorPost("File '$file' is not a regular file");
  817.     return 0;
  818.     }
  819.    
  820.     if (!unlink($file)) {
  821.       &VMware::VMServerd::errorPost("Could not remove file $file. Reason: $!");
  822.       return 0;
  823.     }
  824.  
  825.     return(1);
  826. }
  827.  
  828. #
  829. # Gets the virtual network interfaces on the system.
  830. #
  831. # Input format:
  832. #   No input args.
  833. # 
  834. # Output includes information about each file.  
  835. # Output format:
  836. #
  837. #   .net.interface := the name of the virtual interface
  838. #   .net.type := bridged | hostonly
  839. #   <others> depends on Host_GetBridgedNet_Handler and 
  840. #            Host_GetHostOnlyNet_Handler
  841. #
  842. sub Host_GetVirtualNet_Handler($$) {
  843.     my $in = shift;
  844.     my $out = shift; 
  845.     Host_GetBridgedNet_Handler($in, $out);
  846.     Host_GetHostOnlyNet_Handler($in, $out);
  847.     return(1);
  848. }
  849.  
  850.  
  851. #
  852. # Gets the bridged network interfaces on the system.
  853. #
  854. # Input format:
  855. #   No input args.
  856. # 
  857. # Output includes information about each file.  
  858. # Output format:
  859. #
  860. #   .net.interface := the name of the virtual interface
  861. #   .net.type := bridged
  862. #   .net.ethdev := the real ethernet device to which the virtual 
  863. #                  interface is bound
  864. #
  865. sub Host_GetBridgedNet_Handler($$) {
  866.     my $in = shift;
  867.     my $out = shift; 
  868.  
  869.     my @nets = $out->listElementNames("out", "^net");
  870.     my $i = $#nets + 1;
  871.     $out->setValue(".net[$i].interface", "vmnet0");
  872.     $out->setValue(".net[$i].type", "bridged");
  873.     $out->setValue(".net[$i].ethdev", "eth0");
  874.     return(1);
  875. }
  876.  
  877.  
  878. #
  879. # Gets the hostonly network interfaces on the system.
  880. #
  881. # Input format:
  882. #   No input args.
  883. # 
  884. # Output includes information about each file.  
  885. # Output format:
  886. #
  887. #   .net.interface := the name of the virtual interface
  888. #   .net.type := hostonly
  889. #   .net.hostaddr := the host address for the host machine
  890. #   .net.netmask := the netmask for the virtual network
  891. #
  892. sub Host_GetHostOnlyNet_Handler($$) {
  893.     my $in = shift;
  894.     my $out = shift; 
  895.  
  896.     my @nets = $out->listElementNames("out", "^net");
  897.     my $i = $#nets + 1;
  898.     $out->setValue(".net[$i].interface", "vmnet1");
  899.     $out->setValue(".net[$i].type", "hostonly");
  900. #    $out->setValue(".net[$i].hostaddr", "192.168.0.1");
  901. #    $out->setValue(".net[$i].netmask", "255.255.255.0");
  902.     return(1);
  903. }
  904.  
  905. # Convert a string to its equivalent shell representation
  906. sub shell_string {
  907.   my $single_quoted = shift;
  908.  
  909.   $single_quoted =~ s/'/'"'"'/g;
  910.   # This comment is a fix for emacs's broken syntax-highlighting code --hpreg
  911.   return '\'' . $single_quoted . '\'';
  912. }
  913.  
  914. 1;
  915.  
  916.